(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();
    else if (typeof define === 'function' && define.amd) {
        define([], factory);
    } else {
        var a = factory();
        for (var i in a) {
            (typeof exports === 'object' ? exports : root)[i] = a[i];
        }
    }
})(this, function () {
    return /******/ (function (modules) {
        // webpackBootstrap
        /******/ // The module cache
        /******/
        var installedModules = {};
        /******/
        /******/ // The require function
        /******/
        function __webpack_require__(moduleId) {
            /******/
            /******/ // Check if module is in cache
            /******/ if (installedModules[moduleId]) {
                /******/ return installedModules[moduleId].exports;
                /******/
            }
            /******/ // Create a new module (and put it into the cache)
            /******/
            var module = (installedModules[moduleId] = {
                /******/ i: moduleId,
                /******/ l: false,
                /******/ exports: {}
                /******/
            });
            /******/
            /******/ // Execute the module function
            /******/
            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/
            /******/ // Flag the module as loaded
            /******/
            module.l = true;
            /******/
            /******/ // Return the exports of the module
            /******/
            return module.exports;
            /******/
        }
        /******/
        /******/
        /******/ // expose the modules object (__webpack_modules__)
        /******/
        __webpack_require__.m = modules;
        /******/
        /******/ // expose the module cache
        /******/
        __webpack_require__.c = installedModules;
        /******/
        /******/ // identity function for calling harmony imports with the correct context
        /******/
        __webpack_require__.i = function (value) {
            return value;
        };
        /******/
        /******/ // define getter function for harmony exports
        /******/
        __webpack_require__.d = function (exports, name, getter) {
            /******/ if (!__webpack_require__.o(exports, name)) {
                /******/ Object.defineProperty(exports, name, {
                    /******/ configurable: false,
                    /******/ enumerable: true,
                    /******/ get: getter
                    /******/
                });
                /******/
            }
            /******/
        };
        /******/
        /******/ // getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = function (module) {
            /******/ var getter =
                module && module.__esModule
                    ? /******/ function getDefault() {
                          return module['default'];
                      }
                    : /******/ function getModuleExports() {
                          return module;
                      };
            /******/
            __webpack_require__.d(getter, 'a', getter);
            /******/
            return getter;
            /******/
        };
        /******/
        /******/ // Object.prototype.hasOwnProperty.call
        /******/
        __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ // __webpack_public_path__
        /******/
        __webpack_require__.p = '';
        /******/
        /******/ // Load entry module and return exports
        /******/
        return __webpack_require__((__webpack_require__.s = 13));
        /******/
    })(
        /************************************************************************/
        /******/ [
            /* 0 */
            /***/ function (module, exports, __webpack_require__) {
                'use strict';

                var _typeof =
                    typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
                        ? function (obj) {
                              return typeof obj;
                          }
                        : function (obj) {
                              return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
                          };
                module.exports = {
                    type: function type(ob) {
                        return Object.prototype.toString.call(ob).slice(8, -1).toLowerCase();
                    },
                    isObject: function isObject(ob, real) {
                        if (real) {
                            return this.type(ob) === 'object';
                        } else {
                            return ob && (typeof ob === 'undefined' ? 'undefined' : _typeof(ob)) === 'object';
                        }
                    },
                    isFormData: function isFormData(val) {
                        return typeof FormData !== 'undefined' && val instanceof FormData;
                    },
                    trim: function trim(str) {
                        return str.replace(/(^\s*)|(\s*$)/g, '');
                    },
                    encode: function encode(val) {
                        return encodeURIComponent(val)
                            .replace(/%40/gi, '@')
                            .replace(/%3A/gi, ':')
                            .replace(/%24/g, '$')
                            .replace(/%2C/gi, ',')
                            .replace(/%20/g, '+')
                            .replace(/%5B/gi, '[')
                            .replace(/%5D/gi, ']');
                    },
                    formatParams: function formatParams(data) {
                        var str = '';
                        var first = true;
                        var that = this;
                        if (!this.isObject(data)) {
                            return data;
                        }
                        function _encode(sub, path) {
                            var encode = that.encode;
                            var type = that.type(sub);
                            if (type == 'array') {
                                sub.forEach(function (e, i) {
                                    if (!that.isObject(e)) {
                                        i = '';
                                    }
                                    _encode(e, path + ('%5B' + i + '%5D'));
                                });
                            } else if (type == 'object') {
                                for (var key in sub) {
                                    if (path) {
                                        _encode(sub[key], path + '%5B' + encode(key) + '%5D');
                                    } else {
                                        _encode(sub[key], encode(key));
                                    }
                                }
                            } else {
                                if (!first) {
                                    str += '&';
                                }
                                first = false;
                                str += path + '=' + encode(sub);
                            }
                        }
                        _encode(data, '');
                        return str;
                    },
                    // Do not overwrite existing attributes
                    merge: function merge(a, b) {
                        for (var key in b) {
                            if (!a.hasOwnProperty(key)) {
                                a[key] = b[key];
                            } else if (this.isObject(b[key], 1) && this.isObject(a[key], 1)) {
                                this.merge(a[key], b[key]);
                            }
                        }
                        return a;
                    }
                };

                /***/
            } /* 1 */,
            /***/ function (module, exports, __webpack_require__) {
                'use strict';
                var _typeof =
                    typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
                        ? function (obj) {
                              return typeof obj;
                          }
                        : function (obj) {
                              return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
                          };
                var _createClass = (function () {
                    function defineProperties(target, props) {
                        for (var i = 0; i < props.length; i++) {
                            var descriptor = props[i];
                            descriptor.enumerable = descriptor.enumerable || false;
                            descriptor.configurable = true;
                            if ('value' in descriptor) {
                                descriptor.writable = true;
                            }
                            Object.defineProperty(target, descriptor.key, descriptor);
                        }
                    }
                    return function (Constructor, protoProps, staticProps) {
                        if (protoProps) {
                            defineProperties(Constructor.prototype, protoProps);
                        }
                        if (staticProps) {
                            defineProperties(Constructor, staticProps);
                        }
                        return Constructor;
                    };
                })();
                function _classCallCheck(instance, Constructor) {
                    if (!(instance instanceof Constructor)) {
                        throw new TypeError('Cannot call a class as a function');
                    }
                }

                /*
                 * author: wendu
                 * email: 824783146@qq.com
                 **/

                var util = __webpack_require__(0);
                var isBrowser = typeof document !== 'undefined';

                //EngineWrapper can help  generating  a  http engine quickly through a adapter
                function EngineWrapper(adapter) {
                    var AjaxEngine = (function () {
                        function AjaxEngine() {
                            _classCallCheck(this, AjaxEngine);
                            this.requestHeaders = {};
                            this.readyState = 0;
                            this.timeout = 0; // 0 stands for no timeout
                            this.responseURL = '';
                            this.responseHeaders = {};
                        }
                        _createClass(
                            AjaxEngine,
                            [
                                {
                                    key: '_call',
                                    value: function _call(name) {
                                        if (this[name]) {
                                            this[name].apply(this, [].splice.call(arguments, 1));
                                        }
                                    }
                                },
                                {
                                    key: '_changeReadyState',
                                    value: function _changeReadyState(state) {
                                        this.readyState = state;
                                        this._call('onreadystatechange');
                                    }
                                },
                                {
                                    key: 'open',
                                    value: function open(method, url) {
                                        this.method = method;
                                        if (!url) {
                                            url = location.href;
                                        } else {
                                            url = util.trim(url);
                                            if (url.indexOf('http') !== 0) {
                                                // Normalize the request url
                                                if (isBrowser) {
                                                    var t = document.createElement('a');
                                                    t.href = url;
                                                    url = t.href;
                                                }
                                            }
                                        }
                                        this.responseURL = url;
                                        this._changeReadyState(1);
                                    }
                                },
                                {
                                    key: 'send',
                                    value: function send(arg) {
                                        var that = this;
                                        arg = arg || null;
                                        var self = this;
                                        if (adapter) {
                                            var request = {
                                                method: self.method,
                                                url: self.responseURL,
                                                headers: self.requestHeaders || {},
                                                body: arg
                                            };
                                            util.merge(request, self._options || {});
                                            if (request.method === 'GET') {
                                                request.body = null;
                                            }
                                            self._changeReadyState(3);
                                            var timer = void 0;
                                            self.timeout = self.timeout || 0;
                                            if (self.timeout > 0) {
                                                timer = setTimeout(function () {
                                                    if (self.readyState === 3) {
                                                        that._call('onloadend');
                                                        self._changeReadyState(0);
                                                        self._call('ontimeout');
                                                    }
                                                }, self.timeout);
                                            }
                                            request.timeout = self.timeout;
                                            adapter(request, function (response) {
                                                function getAndDelete(key) {
                                                    var t = response[key];
                                                    delete response[key];
                                                    return t;
                                                }

                                                // If the request has already timeout, return
                                                if (self.readyState !== 3) {
                                                    return;
                                                }
                                                clearTimeout(timer);

                                                // Make sure the type of status is integer
                                                self.status = getAndDelete('statusCode') - 0;
                                                var responseText = getAndDelete('responseText');
                                                var statusMessage = getAndDelete('statusMessage');

                                                // Network error, set the status code 0
                                                if (!self.status) {
                                                    self.statusText = responseText;
                                                    self._call('onerror', {
                                                        msg: statusMessage
                                                    });
                                                } else {
                                                    // Parsing the response headers to array in a object,  because
                                                    // there may be multiple values with the same header name
                                                    var responseHeaders = getAndDelete('headers');
                                                    var headers = {};
                                                    for (var field in responseHeaders) {
                                                        var value = responseHeaders[field];
                                                        var key = field.toLowerCase();
                                                        // Is array
                                                        if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                                                            headers[key] = value;
                                                        } else {
                                                            headers[key] = headers[key] || [];
                                                            headers[key].push(value);
                                                        }
                                                    }
                                                    var cookies = headers['set-cookie'];
                                                    if (isBrowser && cookies) {
                                                        cookies.forEach(function (e) {
                                                            // Remove the http-Only property of the  cookie
                                                            // so that JavaScript can operate it.
                                                            document.cookie = e.replace(/;\s*httpOnly/gi, '');
                                                        });
                                                    }
                                                    self.responseHeaders = headers;
                                                    // Set the fields of engine from response
                                                    self.statusText = statusMessage || '';
                                                    self.response = self.responseText = responseText;
                                                    self._response = response;
                                                    self._changeReadyState(4);
                                                    self._call('onload');
                                                }
                                                self._call('onloadend');
                                            });
                                        } else {
                                            console.error('Ajax require adapter');
                                        }
                                    }
                                },
                                {
                                    key: 'setRequestHeader',
                                    value: function setRequestHeader(key, value) {
                                        this.requestHeaders[util.trim(key)] = value;
                                    }
                                },
                                {
                                    key: 'getResponseHeader',
                                    value: function getResponseHeader(key) {
                                        return (this.responseHeaders[key.toLowerCase()] || '').toString() || null;
                                    }
                                },
                                {
                                    key: 'getAllResponseHeaders',
                                    value: function getAllResponseHeaders() {
                                        var str = '';
                                        for (var key in this.responseHeaders) {
                                            str += key + ':' + this.getResponseHeader(key) + '\r\n';
                                        }
                                        return str || null;
                                    }
                                },
                                {
                                    key: 'abort',
                                    value: function abort(msg) {
                                        this._changeReadyState(0);
                                        this._call('onerror', {
                                            msg: msg
                                        });
                                        this._call('onloadend');
                                    }
                                }
                            ],
                            [
                                {
                                    key: 'setAdapter',
                                    value: function setAdapter(requestAdapter) {
                                        adapter = requestAdapter;
                                    }
                                }
                            ]
                        );
                        return AjaxEngine;
                    })();
                    return AjaxEngine;
                }

                // learn more about keep-loader: https://github.com/wendux/keep-loader
                module.exports = EngineWrapper;

                /***/
            } /* 2 */,
            /***/ function (module, exports, __webpack_require__) {
                'use strict';
                var _createClass = (function () {
                    function defineProperties(target, props) {
                        for (var i = 0; i < props.length; i++) {
                            var descriptor = props[i];
                            descriptor.enumerable = descriptor.enumerable || false;
                            descriptor.configurable = true;
                            if ('value' in descriptor) {
                                descriptor.writable = true;
                            }
                            Object.defineProperty(target, descriptor.key, descriptor);
                        }
                    }
                    return function (Constructor, protoProps, staticProps) {
                        if (protoProps) {
                            defineProperties(Constructor.prototype, protoProps);
                        }
                        if (staticProps) {
                            defineProperties(Constructor, staticProps);
                        }
                        return Constructor;
                    };
                })();
                function _classCallCheck(instance, Constructor) {
                    if (!(instance instanceof Constructor)) {
                        throw new TypeError('Cannot call a class as a function');
                    }
                }
                var utils = __webpack_require__(0);
                var isBrowser = typeof document !== 'undefined';
                var Fly = (function () {
                    function Fly(engine) {
                        _classCallCheck(this, Fly);
                        this.engine = engine || XMLHttpRequest;
                        this.default = this; //For typeScript

                        /**
                         * Add  lock/unlock API for interceptor.
                         *
                         * Once an request/response interceptor is locked, the incoming request/response
                         * will be added to a queue before they enter the interceptor, they will not be
                         * continued  until the interceptor is unlocked.
                         *
                         * @param [interceptor] either is interceptors.request or interceptors.response
                         */
                        function wrap(interceptor) {
                            var resolve = void 0;
                            var reject = void 0;
                            function _clear() {
                                interceptor.p = resolve = reject = null;
                            }
                            utils.merge(interceptor, {
                                lock: function lock() {
                                    if (!resolve) {
                                        interceptor.p = new Promise(function (_resolve, _reject) {
                                            resolve = _resolve;
                                            reject = _reject;
                                        });
                                    }
                                },
                                unlock: function unlock() {
                                    if (resolve) {
                                        resolve();
                                        _clear();
                                    }
                                },
                                clear: function clear() {
                                    if (reject) {
                                        reject('cancel');
                                        _clear();
                                    }
                                }
                            });
                        }
                        var interceptors = (this.interceptors = {
                            response: {
                                use: function use(handler, onerror) {
                                    this.handler = handler;
                                    this.onerror = onerror;
                                }
                            },
                            request: {
                                use: function use(handler) {
                                    this.handler = handler;
                                }
                            }
                        });
                        var irq = interceptors.request;
                        var irp = interceptors.response;
                        wrap(irp);
                        wrap(irq);
                        this.config = {
                            method: 'GET',
                            baseURL: '',
                            headers: {},
                            timeout: 0,
                            params: {},
                            // Default Url params
                            parseJson: true,
                            // Convert response data to JSON object automatically.
                            withCredentials: false
                        };
                    }
                    _createClass(Fly, [
                        {
                            key: 'request',
                            value: function request(url, data, options) {
                                var that = this;
                                var engine = new this.engine();
                                var contentType = 'Content-Type';
                                var contentTypeLowerCase = contentType.toLowerCase();
                                var interceptors = this.interceptors;
                                var requestInterceptor = interceptors.request;
                                var responseInterceptor = interceptors.response;
                                var requestInterceptorHandler = requestInterceptor.handler;
                                var promise = new Promise(function (resolve, reject) {
                                    if (utils.isObject(url)) {
                                        options = url;
                                        url = options.url;
                                    }
                                    options = options || {};
                                    options.headers = options.headers || {};
                                    function isPromise(p) {
                                        // some  polyfill implementation of Promise may be not standard,
                                        // so, we test by duck-typing
                                        return p && p.then && p.catch;
                                    }

                                    /**
                                     * If the request/response interceptor has been locked，
                                     * the new request/response will enter a queue. otherwise, it will be performed directly.
                                     * @param [promise] if the promise exist, means the interceptor is  locked.
                                     * @param [callback]
                                     */
                                    function enqueueIfLocked(promise, callback) {
                                        if (promise) {
                                            promise.then(function () {
                                                callback();
                                            });
                                        } else {
                                            callback();
                                        }
                                    }

                                    // make the http request
                                    function makeRequest(options) {
                                        data = options.body;
                                        // Normalize the request url
                                        url = utils.trim(options.url);
                                        var baseUrl = utils.trim(options.baseURL || '');
                                        if (!url && isBrowser && !baseUrl) {
                                            url = location.href;
                                        }
                                        if (url.indexOf('http') !== 0) {
                                            var isAbsolute = url[0] === '/';
                                            if (!baseUrl && isBrowser) {
                                                var arr = location.pathname.split('/');
                                                arr.pop();
                                                baseUrl = location.protocol + '//' + location.host + (isAbsolute ? '' : arr.join('/'));
                                            }
                                            if (baseUrl[baseUrl.length - 1] !== '/') {
                                                baseUrl += '/';
                                            }
                                            url = baseUrl + (isAbsolute ? url.substr(1) : url);
                                            if (isBrowser) {
                                                // Normalize the url which contains the ".." or ".", such as
                                                // "http://xx.com/aa/bb/../../xx" to "http://xx.com/xx" .
                                                var t = document.createElement('a');
                                                t.href = url;
                                                url = t.href;
                                            }
                                        }
                                        var responseType = utils.trim(options.responseType || '');
                                        var needQuery = ['GET', 'HEAD', 'DELETE', 'OPTION'].indexOf(options.method) !== -1;
                                        var dataType = utils.type(data);
                                        var params = options.params || {};

                                        // merge url params when the method is "GET" (data is object)
                                        if (needQuery && dataType === 'object') {
                                            params = utils.merge(data, params);
                                        }
                                        // encode params to String
                                        params = utils.formatParams(params);

                                        // save url params
                                        var _params = [];
                                        if (params) {
                                            _params.push(params);
                                        }
                                        // Add data to url params when the method is "GET" (data is String)
                                        if (needQuery && data && dataType === 'string') {
                                            _params.push(data);
                                        }

                                        // make the final url
                                        if (_params.length > 0) {
                                            url += (url.indexOf('?') === -1 ? '?' : '&') + _params.join('&');
                                        }
                                        engine.open(options.method, url);

                                        // try catch for ie >=9
                                        try {
                                            engine.withCredentials = !!options.withCredentials;
                                            engine.timeout = options.timeout || 0;
                                            if (responseType !== 'stream') {
                                                engine.responseType = responseType;
                                            }
                                        } catch (e) {
                                            console.log('CatchClause', e);
                                            console.log('CatchClause', e);
                                        }
                                        var customContentType = options.headers[contentType] || options.headers[contentTypeLowerCase];

                                        // default content type
                                        var _contentType = 'application/x-www-form-urlencoded';
                                        // If the request data is json object, transforming it  to json string,
                                        // and set request content-type to "json". In browser,  the data will
                                        // be sent as RequestBody instead of FormData
                                        if (utils.trim((customContentType || '').toLowerCase()) === _contentType) {
                                            data = utils.formatParams(data);
                                        } else if (!utils.isFormData(data) && ['object', 'array'].indexOf(utils.type(data)) !== -1) {
                                            _contentType = 'application/json;charset=utf-8';
                                            data = JSON.stringify(data);
                                        }
                                        //If user doesn't set content-type, set default.
                                        if (!(customContentType || needQuery)) {
                                            options.headers[contentType] = _contentType;
                                        }
                                        for (var k in options.headers) {
                                            if (k === contentType && utils.isFormData(data)) {
                                                // Delete the content-type, Let the browser set it
                                                delete options.headers[k];
                                            } else {
                                                try {
                                                    // In browser environment, some header fields are readonly,
                                                    // write will cause the exception .
                                                    engine.setRequestHeader(k, options.headers[k]);
                                                } catch (e) {
                                                    console.log('CatchClause', e);
                                                    console.log('CatchClause', e);
                                                }
                                            }
                                        }
                                        function onresult(handler, data, type) {
                                            enqueueIfLocked(responseInterceptor.p, function () {
                                                if (handler) {
                                                    //如果失败，添加请求信息
                                                    if (type) {
                                                        data.request = options;
                                                    }
                                                    var ret = handler.call(responseInterceptor, data, Promise);
                                                    data = ret === undefined ? data : ret;
                                                }
                                                if (!isPromise(data)) {
                                                    data = Promise[type === 0 ? 'resolve' : 'reject'](data);
                                                }
                                                data.then(function (d) {
                                                    resolve(d);
                                                }).catch(function (e) {
                                                    reject(e);
                                                });
                                            });
                                        }
                                        function onerror(e) {
                                            e.engine = engine;
                                            onresult(responseInterceptor.onerror, e, -1);
                                        }
                                        function Err(msg, status) {
                                            this.message = msg;
                                            this.status = status;
                                        }
                                        engine.onload = function () {
                                            try {
                                                // The xhr of IE9 has not response field
                                                var response = engine.response || engine.responseText;
                                                if (
                                                    response &&
                                                    options.parseJson &&
                                                    (engine.getResponseHeader(contentType) || '').indexOf('json') !== -1 &&
                                                    // Some third engine implementation may transform the response text to json object automatically,
                                                    // so we should test the type of response before transforming it
                                                    !utils.isObject(response)
                                                ) {
                                                    response = JSON.parse(response);
                                                }
                                                var headers = engine.responseHeaders;
                                                // In browser
                                                if (!headers) {
                                                    headers = {};
                                                    var items = (engine.getAllResponseHeaders() || '').split('\r\n');
                                                    items.pop();
                                                    items.forEach(function (e) {
                                                        if (!e) {
                                                            return;
                                                        }
                                                        var key = e.split(':')[0];
                                                        headers[key] = engine.getResponseHeader(key);
                                                    });
                                                }
                                                var status = engine.status;
                                                var statusText = engine.statusText;
                                                var _data = {
                                                    data: response,
                                                    headers: headers,
                                                    status: status,
                                                    statusText: statusText
                                                };
                                                // The _response filed of engine is set in  adapter which be called in engine-wrapper.js
                                                utils.merge(_data, engine._response);
                                                if ((status >= 200 && status < 300) || status === 304) {
                                                    _data.engine = engine;
                                                    _data.request = options;
                                                    onresult(responseInterceptor.handler, _data, 0);
                                                } else {
                                                    var e = new Err(statusText, status);
                                                    e.response = _data;
                                                    onerror(e);
                                                }
                                            } catch (e) {
                                                console.log('CatchClause', e);
                                                console.log('CatchClause', e);
                                                onerror(new Err(e.msg, engine.status));
                                            }
                                        };
                                        engine.onerror = function (e) {
                                            onerror(new Err(e.msg || 'Network Error', 0));
                                        };
                                        engine.ontimeout = function () {
                                            onerror(new Err('timeout [ ' + engine.timeout + 'ms ]', 1));
                                        };
                                        engine._options = options;
                                        setTimeout(function () {
                                            engine.send(needQuery ? null : data);
                                        }, 0);
                                    }
                                    enqueueIfLocked(requestInterceptor.p, function () {
                                        utils.merge(options, JSON.parse(JSON.stringify(that.config)));
                                        var headers = options.headers;
                                        headers[contentType] = headers[contentType] || headers[contentTypeLowerCase] || '';
                                        delete headers[contentTypeLowerCase];
                                        options.body = data || options.body;
                                        url = utils.trim(url || '');
                                        options.method = options.method.toUpperCase();
                                        options.url = url;
                                        var ret = options;
                                        if (requestInterceptorHandler) {
                                            ret = requestInterceptorHandler.call(requestInterceptor, options, Promise) || options;
                                        }
                                        if (!isPromise(ret)) {
                                            ret = Promise.resolve(ret);
                                        }
                                        ret.then(
                                            function (d) {
                                                //if options continue
                                                if (d === options) {
                                                    makeRequest(d);
                                                } else {
                                                    resolve(d);
                                                }
                                            },
                                            function (err) {
                                                reject(err);
                                            }
                                        );
                                    });
                                });
                                promise.engine = engine;
                                return promise;
                            }
                        },
                        {
                            key: 'all',
                            value: function all(promises) {
                                return Promise.all(promises);
                            }
                        },
                        {
                            key: 'spread',
                            value: function spread(callback) {
                                return function (arr) {
                                    return callback.apply(null, arr);
                                };
                            }
                        }
                    ]);
                    return Fly;
                })();

                //For typeScript

                Fly.default = Fly;
                ['get', 'post', 'put', 'patch', 'head', 'delete'].forEach(function (e) {
                    Fly.prototype[e] = function (url, data, option) {
                        return this.request(
                            url,
                            data,
                            utils.merge(
                                {
                                    method: e
                                },
                                option
                            )
                        );
                    };
                });
                ['lock', 'unlock', 'clear'].forEach(function (e) {
                    Fly.prototype[e] = function () {
                        this.interceptors.request[e]();
                    };
                });
                // Learn more about keep-loader: https://github.com/wendux/keep-loader
                module.exports = Fly;

                /***/
            } /* 7 */,

            ,
            ,
            ,
            ,
            /* 3 */
            /* 4 */
            /* 5 */
            /* 6 */

            /* 8 */
            /* 9 */
            /* 10 */
            /* 11 */
            /* 12 */
            /***/ function (module, exports, __webpack_require__) {
                'use strict';

                //微信小程序适配器
                module.exports = function (request, responseCallback) {
                    var con = {
                        method: request.method,
                        url: request.url,
                        dataType: request.dataType || undefined,
                        header: request.headers,
                        data: request.body || {},
                        responseType: request.responseType || 'text',
                        success: function success(res) {
                            responseCallback({
                                statusCode: res.statusCode,
                                responseText: res.data,
                                headers: res.header,
                                statusMessage: res.errMsg
                            });
                        },
                        fail: function fail(res) {
                            responseCallback({
                                statusCode: res.statusCode || 0,
                                statusMessage: res.errMsg
                            });
                        }
                    };
                    uni.request(con);
                };

                /***/
            } /* 13 */,
            ,
            ,
            ,
            ,
            ,
            /***/ function (module, exports, __webpack_require__) {
                'use strict';

                //微信小程序入口
                var _Fly = __webpack_require__(2);
                var EngineWrapper = __webpack_require__(1);
                var adapter = __webpack_require__(7);
                var wxEngine = EngineWrapper(adapter);
                module.exports = function (engine) {
                    return new _Fly(engine || wxEngine);
                };

                /***/
            }
            /******/
        ]
    );
});
